package com.itheima.marking_system.utils.baidu;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.gson.Gson;
import okhttp3.*;
import org.jetbrains.annotations.NotNull;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.CountDownLatch;

public class Model extends WebSocketListener {

    // 地址与鉴权信息  https://spark-api.xf-yun.com/v1.1/chat   1.5地址  domain参数为general
    // 地址与鉴权信息  https://spark-api.xf-yun.com/v2.1/chat   2.0地址  domain参数为generalv2
    public static final String hostUrl = "https://spark-api.xf-yun.com/v3.5/chat";
    public static final String appid = "e1f33443";
    public static final String apiSecret = "NjQyYWRkNDhlMGIzODU0NWMyN2Y5YmVi";
    public static final String apiKey = "caa7d47f314d9f0f018153ff933e1d60";

    public static List<RoleContent> historyList = new ArrayList<>(); // 对话历史存储集合

    public static String totalAnswer = ""; // 大模型的答案汇总

    // 环境治理的重要性  环保  人口老龄化  我爱我的祖国
    public static String NewQuestion = "";

    public static final Gson gson = new Gson();

    public static List<String> questionList = new ArrayList<>();
    public static boolean closed = false;
    // 个性化参数
    private String userId;
    private Boolean wsCloseFlag;

    private static Boolean totalFlag = true; // 控制提示用户是否输入
    public static String Answer = "";

    // 构造函数
    public Model(String userId, Boolean wsCloseFlag) {
        this.userId = userId;
        this.wsCloseFlag = wsCloseFlag;
    }

    public static void main(String[] args) throws Exception {
        // 调用main函数，传入用户的问题
        List<String> questions = new ArrayList<>();
        questions.add("你好，你会做什么?");
        questions.add("你好，卤菜怎么做?");
        List<String> answers = main(questions);
        for (String answer : answers) {
            System.out.println("Answer: " + answer);
        }
    }

    // 主函数
    /**
     * 主函数，用于启动程序并持续接收用户输入的问题。
     *
     * @param questions 用户输入的问题列表
     * @throws Exception 如果发生异常则抛出。
     */
    public static List<String> main(List<String> questions) throws Exception {
        List<String> answers = new ArrayList<>();
        CountDownLatch latch = new CountDownLatch(questions.size());

        // 重置 Answer 和 totalAnswer，以便处理新问题
        Answer = "";
        totalAnswer = "";
        closed = false;

        // 判断是否已经获取到用户的输入，如果totalFlag为true，表示已经获取到用户输入
        if (totalFlag) {
            totalFlag = false;
            // 构建鉴权url
            String authUrl = getAuthUrl(hostUrl, apiKey, apiSecret);

            // 创建一个OkHttpClient对象，用于发送HTTP请求
            OkHttpClient client = new OkHttpClient.Builder().build();

            // 将鉴权url中的http或https替换为ws或wss，以支持WebSocket协议
            String url = authUrl.toString().replace("http://", "ws://").replace("https://", "wss://");

            // 创建一个Request对象，用于发送WebSocket请求
            Request request = new Request.Builder().url(url).build();

            // 创建一个WebSocket对象，用于与服务器进行通信
            WebSocket webSocket = client.newWebSocket(request, new Model("1", false) {
                @Override
                public void onOpen(@NotNull WebSocket webSocket, @NotNull Response response) {
                    super.onOpen(webSocket, response);
                    for (String question : questions) {
                        NewQuestion = question;
                        MyThread myThread = new MyThread(webSocket, latch);
                        myThread.start();
                    }
                }

                @Override
                public void onMessage(@NotNull WebSocket webSocket, @NotNull String text) {
                    super.onMessage(webSocket, text);
                    latch.countDown();
                }

                @Override
                public void onClosing(@NotNull WebSocket webSocket, int code, @NotNull String reason) {
                    super.onClosing(webSocket, code, reason);
                    webSocket.close(1000, "");
                    closed = true;
                }
            });

            if (!closed) {
                // 等待WebSocket连接关闭
                latch.await();
            }
        }

        // 收集所有回答
        answers.add(Answer);

        return answers;
    }

    /**
     * 判断是否可以添加历史记录。
     * @return 如果历史记录总长度超过12000，则移除前5条记录并返回false；否则直接返回true。
     */
    public static boolean canAddHistory() {  // 由于历史记录最大上线1.2W左右，需要判断是能能加入历史
        int history_length = 0;
        for (RoleContent temp : historyList) {
            history_length = history_length + temp.content.length();
        }
        if (history_length > 12000) {
            historyList.remove(0);
            historyList.remove(1);
            historyList.remove(2);
            historyList.remove(3);
            historyList.remove(4);
            return false;
        } else {
            return true;
        }
    }

    // 线程来发送音频与参数
    class MyThread extends Thread {
        private WebSocket webSocket;
        private CountDownLatch latch;

        public MyThread(WebSocket webSocket, CountDownLatch latch) {
            this.webSocket = webSocket;
            this.latch = latch;
        }

        public void run() {
            try {
                // 创建一个JSONObject对象，用于存储请求的JSON数据
                JSONObject requestJson = new JSONObject();

                // 创建一个JSONObject对象，用于存储header参数
                JSONObject header = new JSONObject();
                header.put("app_id", appid); // 设置app_id
                header.put("uid", UUID.randomUUID().toString().substring(0, 10)); // 生成一个随机的uid

                // 创建一个JSONObject对象，用于存储parameter参数
                JSONObject parameter = new JSONObject();
                JSONObject chat = new JSONObject(); // 创建一个JSONObject对象，用于存储chat参数
                chat.put("domain", "generalv2"); // 设置domain为"generalv2"
                chat.put("temperature", 0.5); // 设置temperature为0.5
                chat.put("max_tokens", 4096); // 设置max_tokens为4096
                parameter.put("chat", chat); // 将chat参数添加到parameter中

                // 创建一个JSONObject对象，用于存储payload参数
                JSONObject payload = new JSONObject();
                JSONObject message = new JSONObject(); // 创建一个JSONObject对象，用于存储message参数
                JSONArray text = new JSONArray(); // 创建一个JSONArray对象，用于存储text参数

                // 如果历史问题列表不为空，则将历史问题添加到text数组中
                if (historyList.size() > 0) {
                    for (RoleContent tempRoleContent : historyList) {
                        text.add(JSON.toJSON(tempRoleContent));
                    }
                }

                // 添加最新问题到text数组中
                RoleContent roleContent = new RoleContent();
                roleContent.role = "user";
                roleContent.content = NewQuestion;
                text.add(JSON.toJSON(roleContent));
                historyList.add(roleContent);

                // 将text数组添加到message中，并将message添加到payload中
                message.put("text", text);
                payload.put("message", message);

                // 将header、parameter和payload添加到requestJson中
                requestJson.put("header", header);
                requestJson.put("parameter", parameter);
                requestJson.put("payload", payload);
                // System.err.println(requestJson); // 可以打印看每次的传参明细（注释掉的代码）

                // 通过webSocket发送请求
                webSocket.send(requestJson.toString());

                // 等待服务端返回完毕后关闭webSocket连接
                while (true) {
                    // System.err.println(wsCloseFlag + "---");
                    Thread.sleep(200);
                    if (wsCloseFlag) {
                        break;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace(); // 打印异常信息
            } finally {
                latch.countDown();
            }
        }
    }

    @Override
    public void onMessage(@NotNull WebSocket webSocket, @NotNull String text) {
        // 将接收到的文本消息转换为JsonParse对象
        JsonParse myJsonParse = gson.fromJson(text, JsonParse.class);
        // 如果header中的code不为0，表示发生错误
        if (myJsonParse.header.code != 0) {
            // 打印错误信息和请求的sid
            System.out.println("发生错误，错误码为：" + myJsonParse.header.code);
            System.out.println("本次请求的sid为：" + myJsonParse.header.sid);
            // 关闭WebSocket连接
            webSocket.close(1000, "");
        }
        // 获取payload中的choices字段的text列表
        List<Text> textList = myJsonParse.payload.choices.text;
        // 遍历text列表，将每个Text对象的content字段拼接到totalAnswer字符串中
        for (Text temp : textList) {
            totalAnswer = totalAnswer + temp.content;
        }
        // 如果header中的status等于2，表示处理完成
        if (myJsonParse.header.status == 2) {
            // 输出提示信息
            Answer = totalAnswer;
            System.out.println(Answer);
            System.out.println();
            System.out.println("*************************************************************************************");
            // 如果可以添加历史记录
            if (canAddHistory()) {
                // 创建RoleContent对象，设置角色为"assistant"，内容为totalAnswer
                RoleContent roleContent = new RoleContent();
                roleContent.setRole("assistant");
                roleContent.setContent(totalAnswer);
                // 将RoleContent对象添加到historyList中
                historyList.add(roleContent);
            } else {
                // 移除historyList中的第一个元素
                historyList.remove(0);
                // 创建RoleContent对象，设置角色为"assistant"，内容为totalAnswer
                RoleContent roleContent = new RoleContent();
                roleContent.setRole("assistant");
                roleContent.setContent(totalAnswer);
                // 将RoleContent对象添加到historyList中
                historyList.add(roleContent);
            }
            // 设置wsCloseFlag为true，表示WebSocket连接已关闭
            wsCloseFlag = true;
            closed = true;
            // 打印一条消息到控制台，表示WebSocket连接已经关闭
            System.out.println("WebSocket连接已关闭");
            // 设置totalFlag为true，表示处理完成
            totalFlag = true;
        }
    }

    @Override
    public void onFailure(WebSocket webSocket, Throwable t, Response response) {
        super.onFailure(webSocket, t, response);
        try {
            if (null != response) {
                int code = response.code();
                System.out.println("onFailure code:" + code);
                System.out.println("onFailure body:" + response.body().string());
                if (101 != code) {
                    System.out.println("connection failed");
                    System.exit(0);
                }
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    // 鉴权方法
    public static String getAuthUrl(String hostUrl, String apiKey, String apiSecret) throws Exception {
        URL url = new URL(hostUrl);
        // 时间
        SimpleDateFormat format = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
        format.setTimeZone(TimeZone.getTimeZone("GMT"));
        String date = format.format(new Date());
        // 拼接
        String preStr = "host: " + url.getHost() + "\n" +
                "date: " + date + "\n" +
                "GET " + url.getPath() + " HTTP/1.1";
        // System.err.println(preStr);
        // SHA256加密
        Mac mac = Mac.getInstance("hmacsha256");
        SecretKeySpec spec = new SecretKeySpec(apiSecret.getBytes(StandardCharsets.UTF_8), "hmacsha256");
        mac.init(spec);

        byte[] hexDigits = mac.doFinal(preStr.getBytes(StandardCharsets.UTF_8));
        // Base64加密
        String sha = Base64.getEncoder().encodeToString(hexDigits);
        // System.err.println(sha);
        // 拼接
        String authorization = String.format("api_key=\"%s\", algorithm=\"%s\", headers=\"%s\", signature=\"%s\"", apiKey, "hmac-sha256", "host date request-line", sha);
        // 拼接地址
        HttpUrl httpUrl = Objects.requireNonNull(HttpUrl.parse("https://" + url.getHost() + url.getPath())).newBuilder().//
                addQueryParameter("authorization", Base64.getEncoder().encodeToString(authorization.getBytes(StandardCharsets.UTF_8))).//
                addQueryParameter("date", date).//
                addQueryParameter("host", url.getHost()).//
                build();

        // System.err.println(httpUrl.toString());
        return httpUrl.toString();
    }

    //返回的json结果拆解
    class JsonParse {
        Header header;
        Payload payload;
    }

    class Header {
        int code;
        int status;
        String sid;
    }

    class Payload {
        Choices choices;
    }

    class Choices {
        List<Text> text;
    }

    class Text {
        String role;
        String content;
    }

    class RoleContent {
        String role;
        String content;

        public String getRole() {
            return role;
        }

        public void setRole(String role) {
            this.role = role;
        }

        public String getContent() {
            return content;
        }

        public void setContent(String content) {
            this.content = content;
        }
    }
}
